1. Field of the Invention
This invention relates to a data processing system and method for executing snapshot dumps, and more particularly to a data processing system and method for executing snapshot dumps in which the state of the program running at a given point in time is re-created by storing memory contents in a memory at regular intervals and restoring the memory contents as needed.
2. Description of the Related Art
When a failure has developed in the data processing unit while the user (or the developer) is executing a program on the data processing unit, he sometimes has to return the program to a certain point in time and re-create the condition. To re-create the condition at a certain point in time of the program, a method generally uses the approach of taking all of the memory contents stored in the memory at regular intervals in the course of executing the program and storing them in a different memory device. In general, this method is called a snapshot dump. When recreation of the program is needed, the state of the program existed at the desired point in time are restored on the basis of the memory contents stored in the different memory device.
As mentioned above, the conventional data processing system and method for executing snapshot dumps has been designed on the basis of the idea of simply re-creating the desired point in the program when a failure has occurred in the course of executing the program, and restarting the program at that point. It should be noted that the program after the restart does not necessarily re-create the same process as that done before the restart.
Moreover, in case of executing snapshot dumps for the program performing transaction processing, it is merely needed to re-create the state of the program on the basis of memory contents stored as a result of the last execution of the snapshot dump in the different memory device. Thus, it is sufficient that the different memory device for storing memory contents may have a memory capacity required for one of the snapshot dumps and the volume of memory contents does not become tremendous.
When the program is of the sequential processing type, there is no problem because even if the program is restarted at a certain point in time, the processing of the program is the same as that before the restart (i.e., because the sequential program has a deterministic execution behavior). However, for example, if the program is of the parallel processing type, not the sequential processing type, there may be a case where the processing of the program after the restart differs from that before the restart, because a program is influenced by a change in another program (i.e., because the sequential program has a nondeterministic execution behavior). Additionally, for example, when a program of the nonsequential processing type is debugged, it is necessary to execute snapshot dumps at regular intervals and store a tremendous volume of data. Consequently, a storage medium that can store enormous amounts of data is required. To re-create the state at the desired point in time of the program, memory contents stored in the different storage device must be loaded into the memory, so that the speed of re-creation cannot be increased. Since all of the memory contents are stored, it takes much time to load the memory contents into the memory when each of the snapshot dumps is executed.
Furthermore, with a data processing device with a cache memory, only snapshot dumps of the main memory are executed without executing snapshot dumps of the main memory. In such a data processing device, a problem arises: the behavior of the cache memory in executing snapshot dumps differs from that when not executing snapshot dumps. When the program is of the sequential processing type, there is no change in operation in accordance with the presence of the cache memory in the data processing device in which the above program is executed. For this reason, in a conventional data processing device, after the memory contents in the cache memory are written back into the main memory, only snapshot dumps for memory contents of the main memory are executed.
However, the program is of the nonsequential processing type causes a problem: a change in the behavior of the cache memory leads to a change in the behavior of the entire system. That is, by executing snapshot dumps, the execution of the program can be restarted even if the behavior of the cache memory has changed, but the processing after the restart of the program can differ from the previous processing. For example, in a debugging operation, the instruction code executed in execution of a snapshot dump differs from that in no execution of a snapshot dump. This means that bugs may surface under specific conditions.